M

MLOG

中文

探索无锁编程的基础，聚焦于原子操作。理解其对高性能并发系统的重要性，并为全球开发者提供国际范例和实践见解。

揭秘无锁编程：原子操作对全球开发者的强大力量

在当今互联的数字世界中，性能和可伸缩性至关重要。随着应用程序为处理日益增长的负载和复杂计算而不断演进，像互斥锁（mutexes）和信号量（semaphores）这样的传统同步机制可能会成为瓶颈。正是在这种背景下，无锁编程（lock-free programming）作为一种强大的范式应运而生，为构建高效、响应迅速的并发系统提供了途径。而无锁编程的核心是一个基本概念：原子操作（atomic operations）。本篇综合指南将为全球开发者揭开无锁编程及其关键原子操作的神秘面纱。

什么是无锁编程？

无锁编程是一种保证系统级进展的并发控制策略。在一个无锁系统中，即使其他线程被延迟或挂起，至少有一个线程总能取得进展。这与基于锁的系统形成对比，在后者中，一个持有锁的线程可能会被挂起，从而阻止任何其他需要该锁的线程继续执行。这可能导致死锁或活锁，严重影响应用程序的响应性。

无锁编程的主要目标是避免与传统锁定机制相关的竞争和潜在的阻塞。通过精心设计算法，在不使用显式锁的情况下操作共享数据，开发者可以实现：

基石：原子操作

原子操作是构建无锁编程的基石。原子操作是指一个操作要么完整执行而不被中断，要么根本不执行。从其他线程的角度来看，一个原子操作似乎是瞬时发生的。当多个线程并发访问和修改共享数据时，这种不可分割性对于维护数据一致性至关重要。

可以这样理解：如果你正在向内存写入一个数字，原子性写入确保整个数字被一次性写入。而非原子性写入可能会在中间被中断，留下一个只写了一部分、已损坏的值，而其他线程可能会读取到这个值。原子操作在非常低的层面上防止了此类竞争条件。

常见的原子操作

虽然具体的原子操作集可能因硬件架构和编程语言而异，但一些基本操作得到了广泛支持：

为什么原子操作对无锁编程至关重要？

无锁算法依赖原子操作来安全地操作共享数据而无需传统锁。比较并交换（CAS）操作尤其关键。考虑一个场景，多个线程需要更新一个共享计数器。一种幼稚的方法可能包括读取计数器、增加它、然后写回。这个序列很容易出现竞争条件：

// 非原子性增量操作（易受竞争条件影响）
int counter = shared_variable;
counter++;
shared_variable = counter;

如果线程A读取了值5，但在它能写回6之前，线程B也读取了5，将其增加到6，并写回了6。然后线程A再写回6，覆盖了线程B的更新。计数器本应是7，但结果只有6。

使用CAS，操作变成：

// 使用CAS的原子性增量操作
int expected_value = shared_variable.load();
int new_value;

do {
    new_value = expected_value + 1;
} while (!shared_variable.compare_exchange_weak(expected_value, new_value));

在这个基于CAS的方法中：

  1. 线程读取当前值（`expected_value`）。
  2. 它计算出 `new_value`。
  3. 它尝试用 `new_value` 替换 `expected_value`，前提是 `shared_variable` 中的值仍然是 `expected_value`。
  4. 如果交换成功，操作完成。
  5. 如果交换失败（因为另一个线程在此期间修改了 `shared_variable`），`expected_value` 会被更新为 `shared_variable` 的当前值，然后循环重试CAS操作。

这个重试循环确保了增量操作最终会成功，从而在没有锁的情况下保证了进展。使用 `compare_exchange_weak`（在C++中很常见）可能会在单次操作中多次执行检查，但在某些架构上可能更高效。为了在单次传递中获得绝对的确定性，可以使用 `compare_exchange_strong`。

实现无锁属性

要被认为是真正的无锁，一个算法必须满足以下条件：

还有一个相关的概念叫做无等待编程（wait-free programming），它要求更强。一个无等待算法保证每个线程都在有限的步骤内完成其操作，无论其他线程的状态如何。虽然理想，但无等待算法的设计和实现通常要复杂得多。

无锁编程的挑战

尽管好处巨大，但无锁编程并非万能药，它也带来了一系列挑战：

1. 复杂性与正确性

设计正确的无锁算法是出了名的困难。它需要对内存模型、原子操作以及即使是经验丰富的开发者也可能忽略的潜在细微竞争条件有深入的理解。证明无锁代码的正确性通常需要形式化方法或严格的测试。

2. ABA问题

ABA问题是无锁数据结构中的一个经典挑战，尤其是在使用CAS的结构中。它发生在当一个值被读取（A），然后被另一个线程修改为B，再修改回A，之后第一个线程才执行其CAS操作。CAS操作会成功，因为值仍然是A，但在第一次读取和CAS之间的数据可能已经发生了重大变化，导致不正确的行为。

示例：

  1. 线程1从共享变量中读取值A。
  2. 线程2将值更改为B。
  3. 线程2将值改回A。
  4. 线程1尝试用原始值A进行CAS。CAS成功了，因为值仍然是A，但线程2所做的中间更改（线程1对此一无所知）可能使该操作的假设失效。

ABA问题的解决方案通常涉及使用带标签的指针或版本计数器。带标签的指针将一个版本号（标签）与指针关联起来。每次修改都会增加标签。CAS操作随后会同时检查指针和标签，这使得ABA问题发生的可能性大大降低。

3. 内存管理

在像C++这样的语言中，无锁结构中的手动内存管理带来了进一步的复杂性。当一个无锁链表中的节点被逻辑上移除时，它不能立即被释放，因为其他线程可能仍在操作它，它们可能在节点被逻辑移除之前已经读取了指向它的指针。这需要复杂的内存回收技术，例如：

带有垃圾回收（GC）的托管语言（如Java或C#）可以简化内存管理，但它们也引入了自身的复杂性，比如GC暂停及其对无锁保证的影响。

4. 性能可预测性

虽然无锁可以提供更好的平均性能，但由于CAS循环中的重试，单个操作可能需要更长的时间。这使得性能比基于锁的方法更难预测，后者等待锁的最长时间通常是有限的（尽管在死锁情况下可能是无限的）。

5. 调试与工具

调试无锁代码要困难得多。标准的调试工具可能无法准确反映系统在原子操作期间的状态，而可视化执行流程也可能具有挑战性。

无锁编程的应用场景？

某些领域对性能和可伸缩性的苛刻要求使无锁编程成为不可或缺的工具。全球范围内的例子比比皆是：

实现无锁结构：一个概念性实践示例

让我们考虑一个使用CAS实现的简单无锁栈。一个栈通常有像 `push` 和 `pop` 这样的操作。

数据结构：

struct Node {
    Value data;
    Node* next;
};

class LockFreeStack {
private:
    std::atomic head;

public:
    void push(Value val) {
        Node* newNode = new Node{val, nullptr};
        Node* oldHead;
        do {
            oldHead = head.load(); // 原子性地读取当前head
            newNode->next = oldHead;
            // 原子性地尝试设置新的head，如果它没有改变的话
        } while (!head.compare_exchange_weak(oldHead, newNode));
    }

    Value pop() {
        Node* oldHead;
        Value val;
        do {
            oldHead = head.load(); // 原子性地读取当前head
            if (!oldHead) {
                // 栈为空，适当地处理（例如，抛出异常或返回哨兵值）
                throw std::runtime_error("Stack underflow");
            }
            // 尝试将当前head与下一个节点的指针进行交换
            // 如果成功，oldHead指向被弹出的节点
        } while (!head.compare_exchange_weak(oldHead, oldHead->next));

        val = oldHead->data;
        // 问题：如何安全地删除oldHead而不发生ABA问题或悬挂指针（use-after-free）？
        // 这就是需要高级内存回收技术的地方。
        // 为演示目的，我们将省略安全删除。
        // delete oldHead; // 在真实的多线程场景中不安全！
        return val;
    }
};

在 `push` 操作中：

  1. 一个新的 `Node` 被创建。
  2. 当前的 `head` 被原子性地读取。
  3. 新节点的 `next` 指针被设置为 `oldHead`。
  4. 一个CAS操作尝试更新 `head` 以指向 `newNode`。如果在 `load` 和 `compare_exchange_weak` 调用之间 `head` 被另一个线程修改了，CAS会失败，然后循环重试。

在 `pop` 操作中：

  1. 当前的 `head` 被原子性地读取。
  2. 如果栈是空的（`oldHead` 为空），则发出错误信号。
  3. 一个CAS操作尝试更新 `head` 以指向 `oldHead->next`。如果 `head` 被另一个线程修改了，CAS会失败，然后循环重试。
  4. 如果CAS成功，`oldHead` 现在指向刚刚从栈中移除的节点。它的数据被检索出来。

这里关键的缺失部分是 `oldHead` 的安全释放。如前所述，这需要像危险指针或基于纪元的回收这样的复杂内存管理技术来防止悬挂指针错误，这是手动内存管理的无锁结构中的一个主要挑战。

如何选择正确的方法：锁与无锁

是否使用无锁编程的决定应基于对应用程序需求的仔细分析：

无锁开发的最佳实践

对于涉足无锁编程的开发者，请考虑以下最佳实践：

结论

无锁编程，由原子操作驱动，为构建高性能、可伸缩和有弹性的并发系统提供了一种复杂的方法。虽然它要求对计算机体系结构和并发控制有更深入的理解，但它在延迟敏感和高竞争环境中的优势是不可否认的。对于致力于开发前沿应用的全球开发者来说，掌握原子操作和无锁设计的原则可以成为一个重要的差异化优势，从而能够创造出更高效、更稳健的软件解决方案，以满足日益并行的世界的需求。

揭秘无锁编程：原子操作对全球开发者的强大力量 | MLOG